// 1.回调地狱 2.多个异步请求同一时间合并结果
// Promise 自带的
// Promise 使用时 需要new Promise
/*
let p = new Promise(function(resolve, reject){
  // resolve('有钱')
  reject('不买')
})
p.then(function(value) {
  console.log('success', value)
}, function(reason) {
  console.log('fail', reason)
})
*/

// 1.Promise 承诺 就是一个类型
// 2.new Promise时需要传递一个executor执行器（同步执行的）
// 3.executor中有两个参数 resolve成功 reject失败
// 4.每个promise的实例上都有一个then方法 then方法中两个函数（成功函数和失败函数）
// 5.promise中有三个状态 pendding状态
// pendding -> resolved   pendding -> rejected
// resolved 不能和 rejected 进行转化

// 用promise处理异步  url必须是绝对路劲
const fs = require('fs')
function read(url, encoding) {
  return new Promise(function(resolve, reject) {
    fs.readFile(url, encoding, function(err, data) {
      if(err) reject(err)
      resolve(data)
    })
  })
}

// then方法执行完会胖段返回结果，如果是promise 会把这个promise执行， 会取到他的结果
// 每次调用then方法后， 会再返回一个新的promise 并不是this
// promise的链式调用 解决了回调嵌套的问题
// catch是捕捉最后的错误
// promise链式调用
 let p2 = read('2.promise/name.txt', 'utf8').then((data) => {
  console.log('then1-->', data)
  // 这里没return 
  return read(data, 'utf8')
}).then(data => {
  // 返回undefined
  console.log('then2-->', data)
  return read(data + '1', 'utf8')
}).then(data => {
  // 返回undefined
  console.log('then3-->', data)
}).then().then().then() // 值的穿透
.catch(err => {
  console.log('catch', err)
  // then总返回promise 会把promise的结果作为下一个then的参数。then返回的是一个普通值， 
  // 把这个普通值作为作为下一次的then的成功的结果
}).then(data => {
  console.log('then000-->', data)
  return Promise.reject('失败了')
}).then(null, function(err) {
  console.log(err)
  throw new Error('错误了')
  // 如果then方法执行抛出了异常会走下一次then的失败回调
}).then(null, function(err) {
  console.log('throw-->' + err)
})
// then 返回一个promise
console.log(p2)

// 多个异步并发执行 需要同一时刻内获取最终的结果
// 计时器
Promise.all([1, 2, 3, 4]).then(function (data) {
  console.log(data)
})
// 数组可以放promise
Promise.all([read('2.promise/name.txt', 'utf8'), read('2.promise/age.txt', 'utf8'), read('2.promise/address.txt', 'utf8')]).then(function (data) {
  console.log(data) // 保证顺序和调用时一样
})
